/**19/09 Tp Final
 * Rotta Damián, Klikailo Héctor
 */
package Logica;

import Excepciones.NoExiste;
import Excepciones.YaExiste;
import java.util.List;
import java.util.Map;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;

public class Empresa { //Es la controladora
//Atributos
private String nombre;
private String telefono;
private boolean estado=false;
private List<Traslado> traslados;
private List<Ingreso> ingresos;
private List<Aplicacion> aplicaciones;
private List<Proveedor> proveedores;
private List<Plantacion> plantaciones;
private Planilla unaPlanilla;
private List<Canchada> canchadas;
private Map<String,Vehiculo> vehiculos;
private List<LibroSalida> librosSalida;
private Map<String,Seccion> secciones;
private Map<String,Deposito> depositos;
private Map<String,Lote> lotes;
private Map<String,Descargadero> descargaderos;

//Constructores
    public Empresa() {
        this.estado=true;
        this.aplicaciones= new LinkedList();
        this.canchadas= new LinkedList();
        this.ingresos= new LinkedList();
        this.librosSalida=new LinkedList();
        this.plantaciones=new ArrayList();
        this.proveedores=new LinkedList();
        this.vehiculos=new HashMap();
        this.unaPlanilla=new Planilla();
        this.secciones= new HashMap();
        this.lotes=new HashMap();
        this.descargaderos= new HashMap();
        this.traslados= new LinkedList();
       
    }
    public Empresa(String nombre, String telefono){
        this.nombre = nombre;
        this.telefono=telefono;
    }
    public Empresa(String nombre, String telefono, List<Ingreso> ingresos, List<Aplicacion> aplicaciones, 
            List<Proveedor> proveedores, List<Plantacion> plantaciones, Planilla unaPlanilla,
            List<Canchada> canchadas, Map<String,Vehiculo> vehiculos, List<LibroSalida> librosSalida, 
            Map<String,Seccion> secciones, Map<String,Lote> lotes, Map<String,Descargadero> descargaderos,
            List<Traslado> traslados){
        this.nombre = nombre;
        this.telefono = telefono;
        this.estado=true;
        this.ingresos = ingresos;
        this.aplicaciones=aplicaciones;
        this.proveedores=proveedores;
        this.plantaciones=plantaciones;
        this.unaPlanilla=unaPlanilla;
        this.canchadas=canchadas;
        this.vehiculos=vehiculos;
        this.librosSalida=librosSalida;
        this.secciones=secciones;
        this.lotes=lotes;
        this.descargaderos=descargaderos;
        this.traslados=traslados;
        }

    public boolean isEstado() {
        return estado;
    }

    public void setEstado(boolean estado) {
        this.estado = estado;
    }

    public List<Ingreso> getIngresos() {
        return ingresos;
    }

    public void setIngresos(List<Ingreso> ingresos) {
        this.ingresos = ingresos;
    }

    public List<Aplicacion> getAplicaciones() {
        return aplicaciones;
    }

    public void setAplicaciones(List<Aplicacion> aplicaciones) {
        this.aplicaciones = aplicaciones;
    }

    public List<Proveedor> getProveedores() {
        return proveedores;
    }

    public void setProveedores(List<Proveedor> proveedores) {
        this.proveedores = proveedores;
    }

    public List<Plantacion> getPlantaciones() {
        return plantaciones;
    }

    public void setPlantaciones(List<Plantacion> plantaciones) {
        this.plantaciones = plantaciones;
    }

    public Planilla getUnaPlanilla() {
        return unaPlanilla;
    }

    public void setUnaPlanilla(Planilla unaPlanilla) {
        this.unaPlanilla = unaPlanilla;
    }

    public List<Canchada> getCanchadas() {
        return canchadas;
    }

    public void setCanchadas(List<Canchada> canchadas) {
        this.canchadas = canchadas;
    }

    public Map<String, Vehiculo> getVehiculos() {
        return vehiculos;
    }

    public void setVehiculos(Map<String, Vehiculo> vehiculos) {
        this.vehiculos = vehiculos;
    }

    public List<LibroSalida> getLibrosSalida() {
        return librosSalida;
    }

    public void setLibrosSalida(List<LibroSalida> librosSalida) {
        this.librosSalida = librosSalida;
    }
//Accesor y Mutator
    public String getNombre() {
        return nombre;
    }

    public String getTelefono() {
        return telefono;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public void setTelefono(String telefono) {
        this.telefono = telefono;
    }
    //Métodos   
    
    public Personal altaPersona(String apellido, String nombre, String dni, String rol) throws YaExiste{
        
        return unaPlanilla.altaPersona(apellido,nombre,dni,rol);
    }
    
    public void altaLeniaSeca(int cantidad, String madera, Descargadero unDescargadero, Ingreso unIngreso){
       unDescargadero.altaLeniaSeca(cantidad,madera,unIngreso);
    }
    
    public void altaLeniaVerde(int cantidad, int porcentajeHumedad,Descargadero unDescargadero, Ingreso unIngreso){
        unDescargadero.altaLeniaVerde(cantidad,porcentajeHumedad,unDescargadero,unIngreso);
    }
    
    public void altaYerbaVerde(int cantidad, String nroSeccion, int humedad, int palo){
        Plantacion unaPlantacion = new Plantacion();
        unaPlantacion.altaYerbaVerde(cantidad,nroSeccion,humedad,palo);
    }
    
     public void listarMantenimiento(String desde, String hasta){}  
     
     public void bajaEmpresa(String nombre){
        if (this.nombre.equals(nombre));
         this.estado=false;
    }
    
    public void bajaDescuento(int nro){
        Iterator it = this.traslados.listIterator();
        Traslado unTraslado;
        boolean seguir=true;
        while (it.hasNext() && (seguir)){
            unTraslado = (Traslado) it.next();
            if(unTraslado.getUnDescuento().getNro()==nro){
                unTraslado.setEstado(false);
                seguir=false;
            }
        }
    }
     
     
    public void bajaDescargadero(int nro){
        Descargadero unDescargadero = this.descargaderos.get(nro);
        unDescargadero.setEstado(false);
    } 
     
     public void bajaDeposito(int nro){
         Deposito unDeposito = this.depositos.get(nro);
         unDeposito.setEstado(false);
     }
     
     public void altaProveedor(){
        Proveedor unProveedor = new Proveedor();
    }
     public void altaQuimico(String nombre, String tipo, Proveedor unProveedor, String nroInventario) throws YaExiste{
        unProveedor.agregarQuimico(nombre, tipo, nroInventario);
        
    }
     public void bajaQuimico(Quimico unQuimico){
      unQuimico.bajaQuimico();
     }
     public void altaEquipamiento(String nombre, String tipo, boolean obligatorio, Proveedor unProveedor, String nroInventario){
         for(Proveedor otroProveedor:proveedores){
            if(otroProveedor.equals(unProveedor)){
                otroProveedor.altaEquipamiento(nombre,tipo,obligatorio,unProveedor,nroInventario);
            }
     }
      }
     public void bajaEquipamiento(Equipamiento unEquipamiento){
       unEquipamiento.bajaEquipamiento();
     }
     public void bajaProveedor(Proveedor unProveedor){
         unProveedor.bajaProveedor();
     }
     public void altaPlanilla(){
       Planilla unaPlanilla = new Planilla();
      }     
     public void bajaPlanilla(Planilla unaPlanilla){
         unaPlanilla.bajaPlanilla();
     }
     public void altaPersonal(){
         Personal unPersonal = new Personal();
     }
     public void bajaPersonal(Personal unPersonal){
         unPersonal.bajaPersonal();
     }
     public void altaParcela(){
      Parcela unaParcela = new Parcela();
     }
     public void bajaParcela(Parcela unaParcela){
         unaParcela.bajaParcela();
     }
     
     public void bajaDescuento(Descuento unDescuento){
         unDescuento.bajaDescuento(unDescuento);
     }
     public void realizarMantenimiento(Vehiculo unVehiculo, Personal unPersonal, Planilla unaPlanilla, String nombre){
         
     }
     public void bajaMantenimiento(Mantenimiento unMantenimiento){
         unMantenimiento.bajaMantenimiento();
     }
     public void trasladar(){
         Traslado unTraslado = new Traslado();
     }
     public void bajaTraslado(Traslado unTraslado){
         unTraslado.bajaTraslado();
     }
     public void altaCarga(){
         CargaDescarga unaCargaDescarga = new CargaDescarga();
     }
     public void bajaCargaDescarga(CargaDescarga unaCargaDescarga){
         unaCargaDescarga.bajaCargaDescarga();
     }
     public void altaAgricola(){
         Agricola unAgricola = new Agricola();
     }
     public void bajaAgricola(Agricola unAgricola){
         unAgricola.bajaAgricola(unAgricola);
     }
     public void altaRodado(){
         Rodado unRodado = new Rodado();
     }
     public void bajaRodado(Rodado unRodado){
         unRodado.bajaRodado();
     }
     
     public void bajaLibroSalida(LibroSalida unLibroSalida){
         unLibroSalida.bajaLibroSalida();
     }
     public void altaVerde(){
         LeniaVerde unaVerde = new LeniaVerde();
     }
     public void bajaSeca(LeniaSeca unaSeca){
         unaSeca.bajaSeca();
     }
     public void agregarSeca(){
         LeniaSeca unaSeca = new LeniaSeca();
     }
     public void secarVerde(LeniaVerde unaVerde){
         unaVerde.bajaVerde();
     }
     public void agregarVerde(){
         LeniaVerde unaVerde = new LeniaVerde();
     }
     public Descargadero altaDescargadero(String numeroSec) throws YaExiste{
         Descargadero unDescargadero;
         if(!descargaderos.containsKey(numeroSec)){
             unDescargadero = new Descargadero(numeroSec);
             descargaderos.put(numeroSec, unDescargadero);
         }else
             throw new YaExiste("El descargadero",numeroSec,"ya está registrado");
     return unDescargadero;
     }
     
     public void altaDescuento(Date fecha, Traslado unTraslado, int nro){
         unTraslado.altaDescuento(fecha,nro);
     }
     
     public void bajaDescargadero(Descargadero unDescargadero){
         unDescargadero.bajaDescargadero(unDescargadero);
     }
     public void altaSeccion(){
         Seccion unaSeccion = new Seccion();
     }
     public void bajaSeccion(Seccion unaSeccion){
         unaSeccion.bajaSeccion(unaSeccion);
      }     
     public void bajaLote(Deposito unDeposito, Lote unLote){
         unDeposito.bajaLote(unLote);
     }
     public void altaDeposito(){
        Deposito unDeposito = new Deposito();
    }
     public void bajaDeposito(Deposito unDeposito){
        unDeposito.bajaDeposito(unDeposito);
    }
     public void almacenar(){}    
     public void vender(Canchada unaCanchada){
        unaCanchada.vender();
    }
     public Vehiculo getVehiculo(){
         Vehiculo unVehiculo = new Vehiculo();
         return unVehiculo;
     }
     
     public void altaSalida(String destino, int kilosPropios, int kilosAlquilados, Date fecha,String hora,String minuto,Vehiculo unVehiculo){
         LibroSalida unLibroSalida = new LibroSalida(fecha,hora,minuto,destino,kilosPropios,kilosAlquilados,minuto,unVehiculo);
         this.librosSalida.add(unLibroSalida);
         
     }
     
     public List<Equipamiento> cargarListaEquipamiento(){
         List<Proveedor> proveedores = this.getProveedores();
         List<Equipamiento> equipamientos= new LinkedList();
         for (Proveedor unProveedor:proveedores){
              List<Insumo> insumos = unProveedor.getInsumos();
              for(Insumo unInsumo:insumos){
                  if (unInsumo instanceof Equipamiento){
                        Equipamiento unEquipamiento = (Equipamiento) unInsumo;
                        equipamientos.add(unEquipamiento);
                  }
              }
         }
         return equipamientos;
     }
     
     public List<Plantacion> cargarPlantacionesPorFecha(Date fecha){
         
         List<Plantacion> plantaciones=null;
         for (Aplicacion unaAplicacion:aplicaciones){
             if(fecha.compareTo(unaAplicacion.getFecha())==0)
                 this.plantaciones.add(unaAplicacion.getPlantacion());
                 
         }
         return plantaciones;
     }
     
     public Map<String,Vehiculo> cargarListaVehiculos(){
         Map<String,Vehiculo> retorno=null;
         Iterator it = this.vehiculos.entrySet().iterator();
         while (it.hasNext()){
             Vehiculo unVehiculo = (Vehiculo) it.next();
             retorno.put(unVehiculo.getNroDominio(),unVehiculo);
             
         }
         return retorno;
     }
     
     public List<Vehiculo> cargarListaVehiculos(Date fecha){
         Vehiculo unVehiculo;
         List<Vehiculo> retorno=null;
         for(Ingreso unIngreso:ingresos){
             if(unIngreso.getUnaCargaDescarga().getFecha().equals(fecha)){
                 unVehiculo = unIngreso.getUnaCargaDescarga().getVehiculo();
                 retorno.add(unVehiculo);
             }
         }
         return retorno;
     }
        
     
          
     public List<Plantacion> cargarListaPlantaciones(){
         return this.plantaciones;
     }
     
     public List<Ingreso> cargarListaIngresos(){
         return this.ingresos;
     }
     
     public List<Ingreso> cargarListaIngresos(Date fecha){
         List<Ingreso> retorno=null;
         for (Ingreso unIngreso:ingresos){
             unIngreso.getUnaCargaDescarga().getFecha().equals(fecha);
             retorno.add(unIngreso);
         }
         return retorno;
     }
     
     public Map<String,Seccion> cargarListaSeccion(){
         return this.secciones;
     }
     
     public Map<String,Personal> cargarListaPersonal(){
         return this.unaPlanilla.getPersonal();
     }
     
     public List<CargaDescarga> cargarListaDescargas(){
         List<CargaDescarga> cargaDescargas=null;
         for (Ingreso unIngreso:ingresos){
             CargaDescarga unaCargaDescarga = unIngreso.getUnaCargaDescarga();
             cargaDescargas.add(unaCargaDescarga);
         }
         return cargaDescargas;
     }
     
     public List<Quimico> cargarListaQuimicos(){
         List<Quimico> retorno=null;
         List<Insumo> insumos=null;
         for(Proveedor unProveedor:proveedores){
            insumos = unProveedor.getInsumos();
            for (Insumo unInsumo:insumos){
                if (unInsumo instanceof Quimico)
                   retorno.add((Quimico) unInsumo);
            }
         }
         return retorno;
     }
     public List<Traslado> cargarListaTraslados(){
         return this.getTraslados();
     }
     
     public List<Canchada> cargarListaCanchadas(){
         return this.canchadas;
     }
     public void altaAplicacion(Date fecha,Plantacion unaPlantacion,List<Personal> personal,Quimico unQuimico){
         Map<String,Personal> personalMap = convertirPersonalAMap(personal);
         Aplicacion unaAplicacion = new Aplicacion(fecha,personalMap,unaPlantacion,unQuimico);
         this.aplicaciones.add(unaAplicacion);
     }
     
     public Map<String,Personal> convertirPersonalAMap(List<Personal> personal){
         Map<String,Personal> retorno=null;
         for (Personal unPersonal:personal)
             retorno.put(unPersonal.getDni(), unPersonal);
         return retorno;
             
     }
     
     public CargaDescarga altaCargaDescarga(Date fecha,Ingreso unIngreso,Vehiculo unVehiculo, List<Seccion> secciones, int pesoBruto){
         return unIngreso.altaCargaDescarga(fecha, unVehiculo, secciones, pesoBruto);
     }
     
     public List<Quimico> cargarQuimicosPorFecha(Date fecha){
         List<Quimico> quimicos = null;
         for (Aplicacion unaAplicacion:aplicaciones){
             if(fecha.compareTo(unaAplicacion.getFecha())==0)
                 quimicos.add(unaAplicacion.getQuimico());
                 
         }
         return quimicos;
     }
     
     public void bajaAplicacion(Quimico unQuimico, Plantacion unaPlantacion, Date fecha){
         Iterator it = this.aplicaciones.listIterator();
         boolean encontrado=false;
         while (it.hasNext() && (!encontrado)){
             Aplicacion unaAplicacion = (Aplicacion) it.next();
             if ((unaAplicacion.getQuimico().getNombre().equals(unQuimico.getNombre()))
                &&(unaAplicacion.getPlantacion().getUbicación().equals(unaPlantacion.getUbicación()))&&
                (fecha.compareTo(unaAplicacion.getFecha())==0)){
                 unaAplicacion.setEstado(false);
                 encontrado=true;
             }
         }
     }
     
     public void bajaCargaDescarga(Ingreso unIngreso){
         CargaDescarga unaCargaDescarga = unIngreso.getUnaCargaDescarga();
         unaCargaDescarga.setEstado(false);
     }
     
     public List<Proveedor> cargarListaProveedores(){
         return this.proveedores;
     }
     public Quimico agregarQuimico(String nombre, String tipo, Proveedor unProveedor, String nroInventario) throws YaExiste {
         return unProveedor.agregarQuimico(nombre,tipo, nroInventario);
     }
     public Proveedor altaProveedor(String nombre, String telefono, List<Insumo> insumos){
         Proveedor unProveedor = new Proveedor(nombre,telefono,insumos);
         this.proveedores.add(unProveedor);
         return unProveedor;
     }
     
     public void altaPrestamo(Date fecha,Personal unPersonal,Equipamiento unEquipamiento){
         for(Proveedor unProveedor:proveedores){
             List<Insumo> insumos = unProveedor.getInsumos();
             for (Insumo unInsumo:insumos){
                 if (unInsumo instanceof Equipamiento)
                     unInsumo.altaPrestamo(fecha,unPersonal,unEquipamiento);
             }
         }
     }
     
     public List<Insumo> cargarListaInsumos(){
         List<Insumo> retorno=null;
       for (Proveedor unProveedor:proveedores){
         List<Insumo> insumos = unProveedor.getInsumos();
         for (Insumo unInsumo:insumos){
             unInsumo.getNombre();
             if(!unProveedor.estaEnLaLista(unInsumo))
                 retorno.add(unInsumo);
        }
        
       }
       return retorno;
     }
     
     public void altaDeposito(String nroDeposito, List<Lote> lotes) throws YaExiste{
         if(!depositos.containsKey(nroDeposito)){
             this.depositos.put(nroDeposito, new Deposito(nroDeposito,lotes));
         }
         else throw new YaExiste("El Deposito",nroDeposito,"ya está registrado");
         
     }
     
     public List<Lote> cargarListaLotes(String nro){
         Deposito unDeposito = this.depositos.get(nro);
         return unDeposito.getLotes();
         
         }
     
     
     public void altaLote(String nro, int kilaje) throws YaExiste{
         Lote unLote = new Lote(nro,kilaje);
         if(!lotes.containsKey(nro))
            lotes.put(nro,unLote);
         else
             throw new YaExiste("El lote",nro,"ya está registrado");
         
     }
     
     public void altaSeccion(String nro) throws YaExiste{
         Seccion unaSeccion = new Seccion(nro);
         if(!secciones.containsKey(nro))
            this.secciones.put(nro,unaSeccion);
         else
             throw new YaExiste("La seccion",nro,"ya está registrada.");
     }
     
     public boolean añadirVehiculo(Vehiculo unVehiculo) throws YaExiste {
         String aux = unVehiculo.getNroDominio();
         boolean retorno=false;
            if(!vehiculos.containsKey(aux)){
                this.vehiculos.put(aux, unVehiculo);
                retorno = true;
            }
            else
                throw new YaExiste("El vehículo de Dominio",aux,"ya existe");
            return retorno;
     }
     
     public void altaYerbaVerde(String cantidad, String nroSeccion, int humedad, int palo){
         //Quiza plantacion si necesite conocer a Materia Prima
     }
     public void altaTraslado(Date fecha, int hora,int minuto, List<Personal>personal, List<Canchada> canchadas, Vehiculo unVehiculo, Descuento unDescuento){
         Traslado unTraslado = new Traslado(fecha,hora,minuto,canchadas,unVehiculo,personal,unDescuento);
         this.traslados.add(unTraslado);
     }
     
     public List<Ingreso> buscarIngresos(Date fechaInicio, Date fechaFin){
        List ingresosEnIntervalo = new ArrayList();
            for (Ingreso unIngreso:ingresos){
                if (fechaInicio.before(unIngreso.getFecha())&&(fechaFin.after(unIngreso.getFecha()))){
                    ingresosEnIntervalo.add(unIngreso);
                }
            }
            return ingresosEnIntervalo;
         }
     public List<Ingreso> buscarMP(List<Ingreso> ingresosEnIntervalos){
         boolean verde=false;
         List <Ingreso> ingresosVerde=new ArrayList();
         for (Ingreso unIngreso:ingresosVerde){
             verde=unIngreso.isVerde();
             if(verde)ingresosVerde.add(unIngreso);
         }
         return ingresosVerde;
     }
    public int sumarVerde(List<Ingreso> ingresosVerde){
        CargaDescarga unaCargaDescarga;
        int total=0;
        for (Ingreso unIngreso:ingresosVerde){
            unaCargaDescarga=unIngreso.getUnaCargaDescarga();
            total+=((unaCargaDescarga.getPesoBruto())-(unaCargaDescarga.getPesoTara()));
        }
        return total; 
    }
    public int densidadSecadero(Date fechaInicio, Date fechaFin){
        int retorno=0;
        List<Ingreso> ingresosEnIntervalo = new ArrayList();
        List<Ingreso> ingresosVerde = new ArrayList();
        CargaDescarga unaCargaDescarga = new CargaDescarga();
        float a=0;
        Ingreso unIngreso= new Ingreso();
        ingresosEnIntervalo=this.buscarIngresos(fechaInicio, fechaFin);
        ingresosVerde=this.buscarMP(ingresosEnIntervalo);
        retorno=this.sumarVerde(ingresosVerde);
        return retorno;
    }    
     public int calcularHs(String dni){
        int horas=0;
        Planilla unaPlanilla = new Planilla();
        horas = unaPlanilla.calcularHs(dni);
        return horas;
    }    
     public int densidadPlantacion(String propietario, String ubicacion, String tipo, String superficie){
        int total=0;
        Plantacion unaPlantacion = this.buscarPlantacion(propietario,ubicacion,tipo,superficie);
        if(unaPlantacion!=null)
            total=unaPlantacion.buscarIngresos();
        else
            System.out.println("No se encontro la plantacion");
        return total;
    }
     public Parcela buscarPlantacion(String propietario, String ubicacion, String tipo,
                                    String superficie, String num, String nombreChacra){
        Plantacion unaPlantacion, retorno=null;
        Parcela unaParcela = null;
        Iterator<Plantacion> it = this.plantaciones.listIterator();
        while (it.hasNext()){
            unaPlantacion = (Plantacion) it.next();
            if (unaPlantacion.isPlantacion(propietario,ubicacion,tipo,superficie)){
                unaParcela = unaPlantacion.agregarParcela(num,nombreChacra,unaPlantacion);}
              }
   
            return unaParcela;
    }    
     
     public Plantacion buscarPlantacion(String propietario, String ubicacion, String tipo, String superficie){
        Plantacion unaPlantacion, retorno=null;
        Iterator<Plantacion> it = this.plantaciones.listIterator();
        while (it.hasNext()){
            unaPlantacion = (Plantacion) it.next();
            if (unaPlantacion.isPlantacion(propietario,ubicacion,tipo,superficie)){
                retorno=unaPlantacion;   
            }
        }
        return retorno;
    }      
     
     public Ingreso registrarIngreso(Date fecha, String hora, String tipo, String origen,Plantacion plantacion, CargaDescarga unaCargaDescarga){
        
        Ingreso unIngreso = new Ingreso(fecha,hora,tipo,origen,plantacion,unaCargaDescarga);
        ingresos.add(unIngreso);
        return unIngreso;
     }
     public List<Mantenimiento> listarMantenimientos(String nroDominio){
         List<Mantenimiento> retorno=null;
         Vehiculo unVehiculo = vehiculos.get(nroDominio);
         unVehiculo.listarMantenimientos();
         return retorno;
     }



    public Plantacion altaPlantaciones(String propietario, String ubicacion, String tipo, String superficie, List<Parcela> parcelas, List<Ingreso> ingresos)throws YaExiste {
        Plantacion retorno = null;
        if(!plantaciones.contains(ubicacion)){
            Plantacion unaPlantacion = new Plantacion(propietario,ubicacion,tipo,superficie, parcelas, ingresos); //To change body of generated methods, choose Tools | Templates.
            plantaciones.add(unaPlantacion);
            retorno = unaPlantacion;
        }
        else{
            throw new YaExiste("La plantacion ubicada en",ubicacion,"ya está registrada");
        }
        return retorno;
        }

    public List<Ingreso> obtenerListIngresos() {
        List<Ingreso> ings=null;
        for (Plantacion miplantacion:plantaciones){ 
            ings.add((Ingreso) miplantacion.getIngresos());
        }
        return ings;
            //To change body of generated methods, choose Tools | Templates.
    }
    public Parcela altaParcela(String numero, String nombreChacra, Plantacion unaPlantacion){
        return this.buscarPlantacion(unaPlantacion.getPropietario(), unaPlantacion.getUbicación(), unaPlantacion.getTipo(), unaPlantacion.getSuperficie(), numero, nombreChacra);
    }
    
   public void bajaCanchada(int cantidad, String nroDeposito, String nroLote) throws NoExiste, Exception{
       Lote unLote = lotes.get(nroLote); 
       if(unLote!=null){
            if(cantidad<=unLote.getKilajeTotal())
                unLote.setKilajeTotal(unLote.getKilajeTotal()-cantidad);
            else
                throw new Exception("La cantidad ingresada es mayor a la cantidad disponible en dicho lote. Verifique.");
       }           
        else
            throw new NoExiste("El lote de numero",nroLote,"no existe");
        
            
        }
        

    public Ingreso registrarIngreso(Date fechaP, String horayMinuto, String tipoIngreso, String origen, CargaDescarga unaCargaDescarga) {
        Ingreso unIngreso = new Ingreso(fechaP,horayMinuto,tipoIngreso,origen,unaCargaDescarga);
        ingresos.add(unIngreso);
        return unIngreso; //To change body of generated methods, choose Tools | Templates.
    }

    public void altaMantenimiento(Date fechaP, List<Personal> personas, Vehiculo unVehiculo) {
        Vehiculo otroVehiculo;
        Iterator it = vehiculos.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry vehic = (Map.Entry) it.next();
            otroVehiculo = (Vehiculo) vehic.getValue();
            if(otroVehiculo.equals(unVehiculo)){
                otroVehiculo.altaMantenimiento(fechaP, personas, unVehiculo);
            }
        }
    
    
    }

    public List<Traslado> getTraslados() {
        return traslados;
    }

    public void setTraslados(List<Traslado> traslados) {
        this.traslados = traslados;
    }

    public Map<String, Seccion> getSecciones() {
        return secciones;
    }

    public void setSecciones(Map<String, Seccion> secciones) {
        this.secciones = secciones;
    }

    public Map<String, Deposito> getDepositos() {
        return depositos;
    }

    public void setDepositos(Map<String, Deposito> depositos) {
        this.depositos = depositos;
    }

    public Map<String, Lote> getLotes() {
        return lotes;
    }

    public void setLotes(Map<String, Lote> lotes) {
        this.lotes = lotes;
    }

    public Map<String, Descargadero> getDescargaderos() {
        return descargaderos;
    }

    public void setDescargaderos(Map<String, Descargadero> descargaderos) {
        this.descargaderos = descargaderos;
    }
    
    
    
    public Map<String, Personal> obtenerListPersonal() {
        return unaPlanilla.getPersonal(); //To change body of generated methods, choose Tools | Templates.
    }

    public void altaRenglon(Personal unaPersona, Date fecha, int MinutosEnt, int MinutosSal) {
        unaPlanilla.altaRenglon(unaPersona, fecha, MinutosEnt, MinutosSal); //To change body of generated methods, choose Tools | Templates.
    }
}

    
    
